COMMENT ⊗   VALID 00050 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	SIZE 11
C00004 00003
C00008 00004
C00011 00005
C00014 00006
C00018 00007
C00022 00008
C00026 00009
C00031 00010
C00032 00011
C00037 00012
C00040 00013
C00042 00014
C00045 00015
C00048 00016
C00052 00017
C00055 00018
C00056 00019
C00059 00020
C00062 00021
C00065 00022
C00068 00023
C00071 00024
C00074 00025
C00077 00026
C00079 00027
C00082 00028
C00085 00029
C00088 00030
C00090 00031	o↓#
C00092 00032
C00093 00033
C00094 00034
C00096 00035
C00099 00036
C00101 00037
C00104 00038
C00107 00039
C00110 00040
C00111 00041
C00114 00042
C00117 00043
C00120 00044
C00123 00045
C00126 00046
C00130 00047
C00133 00048
C00134 00049
C00135 00050	
C00136 ENDMK
C⊗;
;SIZE 11
;VSP 6
;TOPMAR 0
;BOTMAR 0
;LFTMAR 0
;SKIP 1
;KSET CARL;25VGBS KST,FONTS;25VRI KST,,,,
AI:MCLENN;NNTJ6 10.6


↓ `↓ εH1↓ 	EMeta-circular Defn. of PLASMA


↓ `INTRODUCTION
↓ `
↓ ↓`CONVENTIONS to aid in readability of code:
↓ `
↓ `Use FIRST and REST to access data lists, and REPLACE-FIRST to update the first element.
↓ `
↓ p(defun first macro (l)
↓ ↓`(cons 'car (cdr l)) ) 
↓ ↓ 
↓ p(defun rest macro (l)
↓ ↓`(cons 'cdr (cdr l)) )
↓ ↓0
↓ p(defun replace-first macro (l)
↓ ↓`(cons 'rplaca (cdr l)) )
↓ `
↓ `Use ACTION-PART and DATA-PART to access actors in registers.
↓ `Use CONS-ACTOR to build new actors.  The data-part of an actor must be a list.
↓ `
↓ p(defun action-part macro (actor)
↓ ↓`(cons 'car (cdr actor)) ) 
↓ `
↓ p(defun data-part macro (actor)
↓ ↓p(cons 'cdr (cdr actor)) ) 
↓ `
↓ p(defun cons-actor macro (l)
↓ ↓`(cons 'cons (cdr l)) ) 
↓ `
↓ `In order to implement the BACK-TRACE facility efficiently, the convention of making
↓ `the CONTINUATION (if there is one) ↓&first↓'β↓'α in the list of names will be used.
↓ `
↓ `The function NEVER-HAPPEN will be used to issue debugging messages for this
↓ `interpreter.  It will cause an immediate interrupt.
↓ `
↓ ↓`(never-happen any-message-to-be-printed)
↓ `
↓ p(defun never-happen (m)
↓ ↓`(eval (list 'break m t)) )
↓ `
↓ `TO DEFINE A PACKAGE:
↓ ↓`The presence of an expected value will be denoted by a ?
↓ ↓`The presence of an arbitrary number of values (possibly 0) will be denoted by !?
↓ ↓`and will be referred to as POSITIONAL-NOTATION packages.  So far there are just
↓ ↓`two such packages, sequence and collection.
↓ `
↓ ↓`(define-package
↓ α (package-name <primary-element-specification>
↓ α`(selector-1 ?)
↓ αp...
↓ α`(selector-k ?)))
↓ `
↓ `where the <primary-element-specification> and selector-pairs are optional in a
↓ `declaration.  The <primary-element-specification> is either a single value (ie. ?) or
↓ `any number (ie. !?)
↓ `
↓ `EXAMPLES:
↓ `
↓ ↓`(define-package (sequence: !?))
↓ `
↓ ↓`(define-package (eval: ?))
↓ `
↓ ↓`(define-package
↓ α (match:


↓ `↓ εH2↓ 	EMeta-circular Defn. of PLASMA


↓ α`(env: ?)
↓ α`(object: ?)
↓ α`(else-complain-to: ?)))
↓ `
↓ ↓`(define-package
↓ α (apply: ?
↓ α`(then-to: ?)
↓ α`(else-to: ?)) )
↓ `
↓ ↓`(define-package (cursor?))
↓ `
↓ `DEFINE-PACKAGE will be implemented by putting the package definition as a 'package
↓ `property under the atom of the package name.
↓ `
↓ `Use the macro SEND to do a message transmission. (This was previously the role of
↓ `LOAD-REGS.)  All package components ↓&must be↓'β↓'α explicitly mentioned.  If the value of
↓ `a register, eg. target:, is to be left unchanged, its value part may be omitted.
↓ `
↓ ↓`(send
↓ α (normal:
↓ α`(target: ?)
↓ α`(envelope: ?)) )
↓ `
↓ ↓`(send
↓ α (system:
↓ α`(target: ?)
↓ α`(envelope: ?)) )
↓ `
↓ `Either a normal: or a system: package may be sent.  The envelope: package will
↓ `receive the message (which will be either an apply: or a return: package) as its
↓ `primary element.  The target: package will always have an actor as its primary
↓ `element.
↓ `
↓ ↓`(apply: ?
↓ α (then-to: ?)
↓ α (else-to: ?))
↓ `
↓ ↓`(return: ?)
↓ `
↓ `EXAMPLE using a PACKAGE inside SEND,
↓ `
↓ ↓`(send
↓ α (normal:
↓ α`(target: the-target)
↓ α`(envelope: (match:
↓ ∧`(env: e1)
↓ ∧`(object: obj)
↓ ∧`(else-complain-to: cd))
↓ β (then-to: the-continuation)
↓ β (else-to: the-complaint-dept))))
↓ `
↓ `SPECIAL CASES OF SEND:
↓ `
↓ ↓`NORMAL-RETURN
↓ `
↓ α (normal-return message)
↓ α`is an abbreviation for
↓ α (send
↓ α`(normal:
↓ β (target: #then-to)
↓ β (envelope:
↓ β`(return: message))))


↓ `↓ εH3↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ ↓`NORMAL-APPLY-HAND-OFF
↓ `
↓ α (normal-apply-hand-off target)
↓ α`is an abbreviation for
↓ α (send
↓ α`(normal:
↓ β (target: target)
↓ β (envelope:
↓ β`(apply: #message
↓ ∧ (then-to: #then-to)
↓ ∧ (else-to: (debugger))))))
↓ `
↓ ↓`or both target and message may be specified....
↓ `
↓ α (normal-apply-hand-off target  message)
↓ α`is an abbreviation for
↓ α (send
↓ α`(normal:
↓ β (target: target)
↓ β (envelope:
↓ β`(apply: message
↓ ∧ (then-to: #then-to)
↓ ∧ (else-to: (debugger))))))
↓ `
↓ `To access elements of the DATA-PART of #target by name:
↓ ↓`use the function, TARGET-NAMES.
↓ `
↓ ↓`(target-names
↓ α (any-names-specified-in-order-but-put-CONT-first)
↓ α body-of-code-using-these-names)
↓ `
↓ `
↓ p(defun target-names macro (x) 
↓ ↓`(list 'apply (list 'function (cons 'lambda (cdr x)) ) '#target))
↓ `
↓ `MESSENGER-CASES will provide an automatic mechanism for receiving and checking the
↓ `contents of the #messenger register.  It provides a default clause that represents a
↓ `NEVER-HAPPEN error.
↓ `
↓ `For Example,
↓ `
↓ ↓`(messenger-cases
↓ α ((normal: (target: self))
↓ α`body-for-a-normal-messenger)
↓ α ((system:)
↓ α`body-for-a-system-messenger))
↓ `
↓ `The body will contain an ENVELOPE-CASES, a MESSAGE-CASES, and perhaps a TARGET-NAMES
↓ `clause.
↓ `
↓ `ENVELOPE-CASES will provide a similar mechanism for the ENVELOPE register.
↓ `
↓ `For example,
↓ `
↓ ↓`(envelope-cases
↓ α ((apply: =the-message
↓ α`(then-to: cont)
↓ α`(else-to: cd))
↓ β`body-for-an-apply-envelope)
↓ α ((return: =the-message)
↓ β`body-for-an-return-envelope))


↓ `↓ εH4↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ `where the error will be an ENVELOPE-NOT-APPLICABLE message to NEVER-HAPPEN.
↓ `
↓ `MESSAGE-CASES is the construct for implementing a Plasma CASES statement.  Each
↓ `clause will be a package-description.  The package-name and selector-names may be
↓ `used to bind the values of the package selectors to variable names inside the scope
↓ `of a MESSAGE-CASES construct.
↓ `
↓ ↓`(message-cases
↓ α ((package-names-description-1) lisp-body-1)
↓ α0...
↓ α ((package-names-description-k) lisp-body-k))
↓ `
↓ `A package-name-description is defined by the define-package macro,
↓ `
↓ ↓`(package-name args)
↓ `
↓ `If the message is to be received as an unspread message, it may be bound directly in
↓ `the ENVELOPE: package, or within message-cases the special form UNSPREAD-MESSAGE may
↓ `be used.
↓ `
↓ ↓`(unspread-message any-name-to-refer-to-this-message)
↓ `
↓ `UNSPREAD-MESSAGE is not really a package name at all (hence, call it a pseudo-package).
↓ `It is recognized by MESSAGE-CASES, and will be assumed to match successfully.
↓ `
↓ `EXAMPLE using MESSAGE-CASES:
↓ `
↓ ↓`(message-cases
↓ α ((match: (env: e1) (object: obj1) (else-complain-to: cd))
↓ α`lisp-body-1)
↓ α ((eval: e1)
↓ α`lisp-body-3)
↓ α ((sequence: e1 obj1 cd)
↓ α`lisp-body-5))
↓ `
↓ `The MESSAGE-CASES statement provides an default error clause that will report
↓ `MESSAGE-NOT-APPLICABLE.  TO implement an ↓↓else↓ clause, use the pseudo-package,
↓ `
↓ ↓`(else:
↓ α the-lisp-body)
↓ `
↓ `TO CONSTRUCT a PACKAGE, (eg. for inserting in the continuation).
↓ `
↓ ↓`(cons-package (package-name <primary-element-specification>
↓ α (selector-1 value-1)
↓ α0...
↓ α (selector-k value-k)))
↓ `
↓ `The syntax is like that in define-package.
↓ `
↓ `LISP-RULES is the macro analogous to the RULES construct in PLASMA.
↓ `
↓ ↓`(lisp-rules arbitrary-lisp-expression
↓ α`((package-names-description-1) lisp-body-1)
↓ αp...
↓ α`((package-names-description-k) lisp-body-k))
↓ `
↓ `Use #target for SELF in the Plasma code.
↓ `
↓ `The unpack operator (ie. !) and the universal matcher (ie. ?) will be implemented
↓ `as macros; so they may be used directly.  Be sure to delimit them with blanks, however.


↓ `↓ εH5↓ 	EMeta-circular Defn. of PLASMA


↓ `The positional-notation packages will be programmed to recognize ! but it must only be
↓ `used at most once per package, and must ONLY appear before the LAST element if the package
↓ `is part of a pattern.  If the package is used in a send, eg. sequence:, any number
↓ `of ! may be used.  The ? may be used anywhere and any number of times.
↓ `
↓ `Use !? in place of ... otherwise LISP will die.
↓ `
↓ `The following applies only to the macro implementations now.
↓ `
↓ ↓`# prefixes a Register Name
↓ ↓`$ prefixes an ACTION
↓ `
↓ `
↓ `
↓ α`REGISTER FORMATS
↓ `
↓ `#messenger↓ α`↓ β`↓ ∧`↓ ¬`= spread
↓ ↓`#messenger-action↓ ∧`↓ ¬`= $normal or $system
↓ ↓`#envelope↓ β`↓ ∧`↓ ¬`= spread
↓ α`#envelope-action↓ ¬`= $apply or $return
↓ α`#message↓ ∧`↓ ¬`= spread or the-message
↓ β`#message-count↓ ¬`= number-of-message-data-regs-used
↓ β`#message-action↓ ¬`= the-message-action
↓ β`#message-data-1↓ ¬`= first-mess-data-value
↓ β`#message-data-2↓ ¬`= ...
↓ β`#message-data-3
↓ β`#message-data-4
↓ β`#message-data-5
↓ β`#message-data-6
↓ α`#then-to↓ ∧`↓ ¬`= the-continuation
↓ α`#else-to↓ ∧`↓ ¬`= the-complaint-dept
↓ ↓`#target↓ α`↓ β`↓ ∧`↓ ¬`= the-target
↓ ↓`#agent↓ α`↓ β`↓ ∧`↓ ¬`= agent-of-the-activator
↓ α`#debugger↓ ∧`↓ ¬`= the-default-complaint-dept
↓ α`#banker↓ β`↓ ∧`↓ ¬`= the-banker-for-the-activator
↓ `
↓ `The #message-data-i registers will be invisible to users of the package macros (defined on the
↓ `following pages).  All registers (except the "ACTION" registers) must contain either 'SPREAD or
↓ `an ACTOR at all times.  The "ACTION" registers (ie. #messenger-action, #envelope-action,
↓ `#message-action) contain the ACTION-PART of an ACTOR.  Such a scheme is necessary for implementation
↓ `of the garbage-collector and process-switching.
↓ `
↓ ↓`For efficiency sake, whenever the message is a special message packager, use the
↓ ↓`SPREAD format.
↓ `
↓ `The default complaint-dept. will be provided by the agent.
↓ `
↓ p[(↓↓my-agent↓ =default-complaint-dept) ≡
↓ ↓`(≡> (↓↓complaint-dept?↓)
↓ α default-complaint-dept)]
↓ `
↓ p(defun debugger macro (l)
↓ ↓`'(first (data-part #agent)) )
↓ `
↓ `IMPLEMENTATION OF MACROS
↓ `
↓ α`(fix-package package-instance)
↓ `
↓ ↓`will reorder the parameters of a package-instance and return them in canonical
↓ ↓`order in the following form:
↓ `
↓ α`(package-name # (arms-in-canonical-order))


↓ `↓ εH6↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ ↓`where # is either the number of arguments of the package definition, or ? if not
↓ ↓`a fixed length.  And where each arm will be a list of the value that appeared
↓ ↓`with the selector.  Thus NIL will represent each unmodified-arm-value.
↓ `
↓ `It will be manditory for a package to be completely specified (ie. no arms may be
↓ `omitted) when sending a package.  However, on a receive, only those components of
↓ `interest need be specified.  In this way FIX-PACKAGE will be able to detect errors
↓ `of the form, arm-omitted, or value-of-arm not an actor.
↓ `
↓ `A function CANONICALIZE is a simplified version of FIX-PACKAGE, expressed below:
↓ `
↓ p(defun canonicalize (l)
↓ ↓`(prog (z)
↓ α (setq z (fix-package L))
↓ α (cons (car z) (cddr z)) ))
↓ `
↓ `The convention for automatically converting between package names and actor names
↓ `will simply be to concatenate a $ on to the front of the package name.  Remember
↓ `names beginning with $ signify ↓↓ACTION↓.
↓ `
↓ `FOR EXAMPLE,
↓ `
↓ ↓`(normal:
↓ α (target: E1)
↓ α (envelope: E2))
↓ `
↓ ↓`will be returned by CANONICALIZE as:  ($normal: E1 E2)
↓ `
↓ `The following lisp code describes the procedure for the SEND macro.  Of course it
↓ `will be implemented more efficiently.
↓ `
↓ p(defun send fexpr (l)
↓ ↓`(setq l (car l))
↓ ↓`(cond
↓ α ((eq (car l) 'normal:)
↓ α0(setq #message-action '$normal:))
↓ α ((eq (car l) 'system:)
↓ α0(setq #messenger-action '$system:))
↓ α (t
↓ α0(never-happen (send 'load l) 'bad-messenger)))
↓ ↓`(setq l (cdr (canonicalize l)))
↓ ↓`(cond
↓ α ((null (car l)))
↓ α (t
↓ α0(setq #target (eval (caar l))) ))
↓ ↓`(setq l (cadr l))
↓ ↓`(cond
↓ α ((null l)
↓ α`...↓ β`)))
↓ `
↓ `Thus inside the SEND macro, as long as CAR of the value of a package is a package-name
↓ `it will not be necessaary to explicitly call CONS-PACKAGE; SEND will do it.
↓ `****************************************************************************************
↓ `
↓ `Comments on REDUCING FORMS
↓ `
↓ ↓`<expression> ::=  <identifier> | (...) | (...<distinguished-identifier>...) | [...]
↓ `
↓ `An expression may play the role of either a PATTERN or a SKELETON, where patterns eat MATCH-REDUCE
↓ `messages, and skeletons eat REDUCE messages.
↓ `


↓ `↓ εH7↓ 	EMeta-circular Defn. of PLASMA


↓ `When an expression containing a ↓↓distinguished-symbol↓ is sent a REDUCE message, the expression will send
↓ pa REDUCE-APPLY message to the ↓↓distinguished-symbol↓.  The ↓↓distinguished-symbol↓ will respond
↓ `to the REDUCE-APPLY message by sending a MATCH-REDUCE message to each of its expressions
↓ `that play the role of a pattern, and will send REDUCE messages to each of its expressions that play
↓ `the role of skeletons.  And only this ↓↓distinguished-symbol↓ knows how to determine these roles, and what
↓ `to do with the responses.
↓ `
↓ `For example, when an expression containing a ≡> is sent a REDUCE message, ≡> will be given control.
↓ `It knows the first expression after the ≡> is a pattern, and that the remaining expressions
↓ `are skeletons.  The appropriate messages are sent, the reduced-expressions are gathered up, and
↓ `an ARROW-TRANSMITTER is returned.
↓ `
↓ `Consider REDUCTION of the following FORM:
↓ `
↓ ↓`(rules n
↓ α (≡> (x + 1)
↓ α`(n + 1) )
↓ α (≡> (↓↓and↓ =y (> 5))
↓ α`(n - 1) ))
↓ `
↓ `A REDUCE message is sent to the form, (rules ...). Since there are no ↓↓distinguished-symbols↓, the REDUCE
↓ `is passed on to each expression of this form, ie. n, (≡> (x + 1)(n + 1)), (≡> (↓↓and↓ =y (> 5))(n - 1)).
↓ `
↓ `When a RECEIVE statement, ie. (≡> ...), is sent a REDUCE message, control is given to the ↓↓distinguished-symbol↓, ≡> ,
↓ `by sending it a REDUCE-APPLY message.
↓ `
↓ `When ≡> receives a REDUCE-APPLY, it makes sure that ≡> is the first symbol in the form,
↓ `and then sends a MATCH-REDUCE to its pattern and REDUCE messages to its skeletons.
↓ `So in this example, both (x + 1) and (↓↓and↓ =y (> 5)) are sent MATCH-REDUCE messages,
↓ `while (n + 1) and (n - 1) are sent REDUCE messages.
↓ `
↓ `Since the form (x + 1) contains no ↓↓distinguished symbols↓, each of its expressions will
↓ `be sent a REDUCE message.
↓ `
↓ `Since the form (↓↓and↓ =y (> 5)) contains a ↓↓distinguished-symbol↓, a MATCH-REDUCE-APPLY
↓ `message will be sent to the first ↓↓distinguished-symbol↓, ie. ↓↓and↓.
↓ `
↓ `When ↓↓and↓ receives a MATCH-REDUCE-APPLY message, it sends a MATCH-REDUCE to each of
↓ `its patterns; it has no skeletons.
↓ `
↓ `How can a simple transmitter, eg. <= or => be sent a MATCH-REDUCE-APPLY message?
↓ `
↓ ↓`(rules x
↓ α (≡> (car? => L)
↓ α`(cdr? => L)))
↓ `
↓ `In the above actor, the expression (car? => L) is the pattern so gets sent a MATCH-REDUCE
↓ `message.  Because => is distinguished, it gets sent the pattern expression with a
↓ `MATCH-REDUCE-APPLY message.
↓ `
↓ `CURRENT STATE OF THE ARROW-HOOD
↓ `
↓ ↓`=>  is a normal FUNCTION CALL
↓ ↓`=>> is a RETURN, or a CO-ROUTINE CALL (ie. no continuation)
↓ ↓`==> sends an ENVELOPE which contains explicit MESSAGE, CONTINUATION, COMPLAINT-DEPT.
↓ `
↓ ↓`The syntax for SYSTEM-LEVEL message passing is analogous:
↓ α ∞>
↓ α ∞>>
↓ α ∞∞>
↓ `
↓ p(3 =>


↓ `↓ εH8↓ 	EMeta-circular Defn. of PLASMA


↓ ↓`(≡≡> (↓↓apply:↓ =n
↓ α`(↓↓then-to:↓ =c))
↓ α (c <<= (n+1))) )
↓ `
↓ p(↓↓apply:↓ 4) ==>
↓ `
↓ α`will fail to match when sent to
↓ `
↓ ↓`(≡≡> (↓↓apply:↓ =n
↓ α`(↓↓then-to:↓ =c))
↓ α (c <<= n))
↓ `
↓ α`because (↓↓apply:↓ 4) will get packaged as a RETURN.



↓ `↓ εH9↓ 	EMeta-circular Defn. of PLASMA


↓ `Identifiers are basic to the definition of plasma. They may be usually
↓ `thought of as interned atoms without values or property-lists in lisp.
↓ `The interesting properties of identifiers are with the unreduced and reduced
↓ `identifiers. An unreduced-identifier reduces itself by looking itself up in the
↓ `reduction environment and returning what is found there. There are basically
↓ `three types of values that will be found: definite values, idefinite values,
↓ `and distinguished values. A definite value is found when an identifier is bound
↓ `to a constant that cannot be changed. No operations will cause the run-time code
↓ `to use a different actor as the value of this identifier. An indefinite value
↓ `is found when the exact binding for the identifier is not known at reduction-time.
↓ `the indefinite value is essentially an access function that allows the value to
↓ `be used at run-time to be found at run-time. This kind of value must be used
↓ `if a setq is to change the binding of this identifier for this code.  The object
↓ `returned knows how to evaluate itself.
↓ `
↓ `A distinguished value is a definite value that can affect the parsing
↓ `of the code at reduction time. Indefinite values cannot be distinguished
↓ `since if they are changed, the reduction would have to be reparsed anyway.
↓ `
↓ `A reduced identifier is evaluated by evaluating its associated value.
↓ `if the associated value is a definite value, the value is returned. If it is an
↓ `indefinite value, the access function is invoked with the execution environment
↓ `as a parameter and the value of the identifier is returned.
↓ `
↓ p[cons-identifier: ≡
↓ ↓⊂(≡> [=atom]
↓ ↓identifier: <≡>
↓ ↓`(self ≡
↓ α(cases
↓ α (≡> (↓↓display:↓ =customer) (customer <= self))
↓ α (≡> (↓↓equal?↓ =id) (eq id self)))))]
↓ `
↓ `[cons-unreduced-identifiers ≡
↓ ↓ (≡> [=identifier =cursor]
↓ ↓unreduced-identifier ≡
↓ ↓@(self ≡
↓ ↓`(cases
↓ α(≡> (↓↓reduce:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd))
↓ α@(cons-reduced-identifier self
↓ β`(env <= (↓↓lookup:↓ identifier
↓ ∧`(↓↓else-complain-to:↓
↓ ¬ (≡> =message
↓ ¬`(cd <= [message cursor])))))))
↓ α(≡> (↓↓match-reduce:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd))
↓ α@(cons-reduced-identifier self
↓ β`(env <= (↓↓lookup:↓ identifier
↓ ∧`(↓↓else-complain-to:↓
↓ ¬ (≡> =message
↓ ¬`(cd <= [message cursor])))))))
↓ α(≡≡> (and
↓ β(↓↓apply:↓
↓ β (↓↓reduce-apply:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)))
↓ β=whole-message)
↓ α`((env <= (↓↓lookup:↓ identifier
↓ ∧`(↓↓else-complain-to:↓
↓ ¬ (≡> =message


↓ `↓ ε@10↓ 	EMeta-circular Defn. of PLASMA


↓ ¬`(cd <= [message cursor])))))
↓ αp<== whole-message))
↓ α(≡≡>
↓ α (and
↓ α@(↓↓apply:↓
↓ α`(↓↓match-reduce-apply:↓
↓ β(↓↓env:↓ =env)
↓ β(↓↓else-complain-to:↓ =cd)))
↓ α@=whole-message)
↓ α ((env <=
↓ α`(↓↓lookup:↓ identifier
↓ β(↓↓else-complain-to:↓
↓ β (≡> =message
↓ β`(cd <= [message cursor])))))
↓ α0<== whole-message))
↓ α(≡> (↓↓cursor?↓ cursor))
↓ α(≡> (↓↓down:↓ (↓↓else-complain-to:↓ =cd))
↓ α@(cd <= (↓↓cant:↓)))
↓ α(≡> (↓↓link-up:↓ =upward-cursor)
↓ α@(cons-unreduced-identifier identifier upward-cursor))
↓ α(≡> (↓↓display:↓ =customer)
↓ α@(customer <= identifier))
↓ α(≡> (↓↓quasi-quote:↓) =identifier)
↓ α(≡> (↓↓match-quasi-quote:↓ (↓↓env:↓ =env))
↓ α@(↓↓match-reduced:↓ (↓↓env:↓ env) (↓↓pattern:↓ identifier))))))]
↓ `
↓ ↓[cons-reduced-identifier ≡
↓ ↓ (≡> [=unreduced-id =value]
↓ ↓⊂reduced-identifier <≡>
↓ ↓`(cases
↓ α(≡> (↓↓eval:↓ =env)
↓ α@(value <= (↓↓eval:↓ env)))
↓ α(≡> (↓↓match:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd)
↓ α`(↓↓object:↓ =obj))
↓ α@(rules (equal? (value <= (↓↓eval:↓ env)) obj)
↓ α`((↓↓true:↓)
↓ αp(↓↓matched:↓ (↓↓env:↓ env) (↓↓else-complain-to:↓ cd)))
↓ α`((↓↓false:↓)
↓ αp(cd <= (↓↓nomatch:↓)))))
↓ α(≡> (↓↓display:↓ =customer)
↓ α@(unreduced-id <= (↓↓display:↓ customer)))
↓ α(≡> (↓↓unreduced?↓) unreduced-id)))]



↓ `↓ ε@11↓ 	EMeta-circular Defn. of PLASMA


↓ `An unreduced-binder is created by the reader upon encountering an equal sign, ie. =
↓ `
↓ p[cons-unreduced-binder ≡
↓ ↓`(≡> [=the-identifier =cursor]
↓ ↓⊂unreduced-binder <≡>
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓match-reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match-reduced:↓
↓ ∧ (↓↓env:↓
↓ ∧`(env <=
↓ ¬ (↓↓extend:↓
↓ ¬`(↓↓identifier:↓ the-identifier)
↓ ¬`(↓↓binder:↓
↓ ε (cons-unreduced-identifier
↓ ε`the-identifier
↓ ε`self))) ))
↓ ∧ (↓↓pattern:↓
↓ ∧`(cons-reduced-binder the-identifier self))) )
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓link-up:↓ =upward-cursor)
↓ β`(link-up-unary
↓ ∧ the-identifier
↓ ∧ upward-cursor
↓ ∧ cons-unreduced-binder)) )))]
↓ `
↓ p[cons-reduced-binder ≡
↓ ↓`(≡> [=the-identifier =form]
↓ ↓⊂reduced-binder <≡>
↓ α (cases
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (↓↓matched:↓
↓ β`(↓↓env:↓
↓ ∧ (env <=
↓ ∧`(↓↓extend:↓
↓ ¬ (↓↓identifier:↓ the-identifier)
↓ ¬ (↓↓binder:↓ object)) ))
↓ β`(↓↓complaint-dept:↓ cd)) )
↓ α`(≡> (↓↓unreduced?↓)
↓ β form) ))]



↓ `↓ ε@12↓ 	EMeta-circular Defn. of PLASMA


↓ `The reader produces unreduced-sequences upon encountering square brackets, ie. [...]
↓ `
↓ `[cons-unreduced-sequence ≡
↓ ↓ (≡> [=exprs =cursor]
↓ ↓⊂unreduced-sequence <≡>
↓ ↓0(self ≡
↓ ↓P(cases
↓ ↓p(≡> (↓↓reduce:↓
↓ αP(↓↓env:↓ =env)
↓ αP(↓↓else-complain-to:↓ =cd))
↓ α⊂(cons-reduced-sequence
↓ αP(reduce-elements-of-sequence env cd exprs)
↓ αPself))
↓ ↓p(≡> (↓↓match-reduce:↓
↓ αP(↓↓env:↓ =env)
↓ αP(↓↓else-complain-to:↓ =cd))
↓ α⊂(↓↓match↓ (match-reduce-elements-of-sequence env cd exprs) ↓↓to↓
↓ αP(↓↓match-reduced:↓
↓ β⊂(↓↓env:↓ =extended-env)
↓ β⊂(↓↓pattern:↓ =match-reduced-exprs)) ↓↓then↓
↓ α⊂(↓↓match-reduced:↓
↓ αP(↓↓env:↓ extended-env)
↓ αP(↓↓pattern:↓
↓ β⊂(cons-reduced-sequence
↓ βPmatch-reduced-exprs
↓ βPself)))))
↓ ↓p(≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ α⊂(rules exprs
↓ α0(≡> []
↓ αP(cd <= (↓↓exhausted:↓) ))
↓ α0(≡> [=first-expr !=rest-exprs]
↓ αP(↓↓next:↓ first-expr
↓ β⊂(↓↓rest:↓
↓ βP(cons-unreduced-sequence rest-exprs cursor)))) ))
↓ ↓p(≡> (↓↓down:↓ (↓↓cursor:↓ =new-cursor))
↓ α⊂(cons-delimiter-cursor
↓ αPexprs
↓ αP[]
↓ αPnew-cursor
↓ αP(↓↓identifier:↓ '] ))
↓ ↓p(≡> (↓↓cursor?↓)
↓ α⊂cursor)
↓ ↓p(≡> (↓↓quasi-quote:↓
↓ αP(↓↓env:↓ =env)
↓ αP(↓↓else-complain-to:↓ =cd))
↓ α⊂(cons-unreduced-sequence
↓ αP[!((cons-unreduced-sequence exprs cursor) <=
↓ β⊂(↓↓reduce:↓
↓ βP(↓↓env:↓ env)
↓ βP(↓↓else-complain-to:↓ cd)) )]
↓ αPcursor))
↓ ↓p(≡> (↓↓link-up:↓ =upward-cursor)
↓ α⊂(cons-unreduced-sequence
↓ αP[!(link-up-delimited
↓ β0exprs
↓ β0[]
↓ β0upward-cursor
↓ β0cons-unreduced-sequence)]
↓ αPupward-cursor))
↓ ↓p(≡> (↓↓display:↓ =the-customer)
↓ α⊂(tell the-customer
↓ αP(↓↓left-delim:↓ (↓↓bracket:↓))


↓ `↓ ε@13↓ 	EMeta-circular Defn. of PLASMA


↓ β⊂(↓↓elements:↓ ! exprs)
↓ β⊂(↓↓right-delim:↓ (↓↓bracket:↓))))
↓ ↓p(≡> (↓↓match-quasi-quote:↓
↓ `only reason to do this is to produce an unreduced sequence
↓ β(↓↓env:↓ =env)
↓ β(↓↓else-complain-to:↓ =cd))
↓ α@(↓↓match↓
↓ β((cons-unreduced-sequence exprs cursor) <=
↓ β@(↓↓match-reduce:↓
↓ ∧(↓↓env:↓ env)
↓ ∧(↓↓else-complain-to:↓ cd))) ↓↓to↓
↓ β@(↓↓match-reduced:↓
↓ ∧(↓↓env:↓ =extended-env)
↓ ∧(↓↓pattern:↓ =reduced-patterns)) ↓↓then↓
↓ β@(↓↓match-reduced:↓
↓ ∧(↓↓env:↓ extended-env)
↓ ∧(↓↓pattern:↓
↓ ∧@(cons-unreduced-sequence
↓ ¬reduced-patterns
↓ ¬self))) ))
↓ ↓p(≡> (↓↓label-reduce-eqn:↓
↓ αP(↓↓env:↓ =env)
↓ αP(↓↓else-complain-to:↓ =cd))
↓ α⊂(rules exprs
↓ α0(≡> [=identifier '≡ =skeleton]
↓ αP(↓↓let↓
↓ β⊂{[reduced-identifier =
↓ ∧`(identifier <=
↓ ¬ (↓↓reduce:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)) )]
↓ β [reduced-skeleton =
↓ ∧`(skeleton <=
↓ ¬ (↓↓reduce:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)) )]}
↓ β⊂(env <=
↓ βP(↓↓patch:↓
↓ ∧⊂(↓↓identifier:↓ reduced-identifier)
↓ ∧⊂(↓↓value:↓ reduced-skeleton)) )
↓ β⊂(cons-reduced-sequence
↓ βP[reduced-identifier '≡ reduced-skeleton]
↓ βPself) ))))
↓ ↓p(≡> (↓↓let-reduce-eqn:↓
↓ αP(↓↓env:↓ =env)
↓ αP(↓↓else-complain-to:↓ =cd))
↓ α⊂(rules exprs
↓ α0(≡> [=identifier '= =skeleton]
↓ αP(↓↓let↓
↓ β⊂{[reduced-identifier =
↓ ∧`(identifier <=
↓ ¬ (↓↓reduce:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)) )]
↓ β [reduced-skeleton =
↓ ∧`(skeleton <=
↓ ¬ (↓↓reduce:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)) )]}
↓ β⊂(↓↓let-reduced-eqn:↓
↓ βP(↓↓env:↓
↓ ∧⊂(env <=


↓ `↓ ε@14↓ 	EMeta-circular Defn. of PLASMA


↓ ∧P(↓↓extend:↓
↓ ¬⊂(↓↓identifier:↓ identifier)
↓ ¬⊂(↓↓binder:↓ reduced-skeleton)) ))
↓ βP(↓↓reduced-eqn:↓
↓ ∧⊂(cons-reduced-sequence
↓ ∧P[reduced-identifier '= reduced-skeleton]
↓ ∧Pself))) )))) )))]
↓ `
↓ `REDUCED-SEQUENCES are created by sending UNREDUCED-SEQUENCES $reduce messages.
↓ `The UNPACK-ACTOR (ie. !) has special meaning to REDUCED-SEQUENCES, ie. unpacking the
↓ `following expression.  But SEQUENCES treat ! just like any other ACTOR.
↓ `
↓ p[cons-reduced-sequence ≡
↓ ↓`(≡> [=reduced-exprs =unreduced-seq]
↓ ↓⊂reduced-sequence <≡>
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β ([reduced-exprs []] =>
↓ β`(eval-skeletons ≡
↓ ∧ (≡> [=rest-skeletons =accumulated-values]
↓ ∧`(rules rest-skeletons
↓ ¬ (≡> []
↓ ¬`(reverse accumulated-values))
↓ ¬ (≡> [(↓↓is-reduced-unpack:↓ =reduced-unpack)]
↓ ¬`[!(reverse accumulated-values)
↓ ¬p!(reduced-unpack <= (↓↓eval:↓ env)) ])
↓ ¬ (≡> [(↓↓is-reduced-unpack:↓ =reduced-unpack) !=remainder]
↓ ε (eval-skeletons
↓ ε`remainder
↓ ε`[!(reverse (reduced-unpack <= (↓↓eval:↓ env) ))
↓ εp!accumulated-values]) )
↓ ¬ (≡> [=first !=rest]
↓ ¬`(eval-skeletons
↓ ε rest
↓ ε [(first <= (↓↓eval:↓ env)) !accumulated-values])) ))) ))
↓ α`(≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ β (rules reduced-exprs
↓ β`(≡> []
↓ ∧ (cd <= (↓↓exhausted:↓) ))
↓ β`(≡> [=first-expr !=rest-reduced-exprs]
↓ ∧ (↓↓next:↓ first-expr
↓ ∧`(↓↓rest:↓
↓ ¬ (cons-reduced-sequence rest-reduced-exprs unreduced-seq)))) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-seq)
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (unreduced-seq <= (↓↓display:↓ the-customer)))
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (rules reduced-exprs
↓ β`(≡> []
↓ ∧ (rules obj
↓ ∧`(≡> []
↓ ¬ (↓↓matched:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓complaint-dept:↓ cd)) )
↓ ∧`(↓↓else↓
↓ ¬ (cd <= (↓↓nomatch:↓))) ))
↓ β`(≡> [(↓↓is-reduced-unpack:↓ =reduced-unpack) !=remaining-patterns]
↓ ∧ (↓↓match↓ (reduced-unpack <=


↓ `↓ ε@15↓ 	EMeta-circular Defn. of PLASMA


↓ ¬`(↓↓partial-match:↓
↓ ε (↓↓env:↓ =env)
↓ ε (↓↓else-complain-to:↓ =cd)
↓ ε (↓↓object:↓ =obj)) )
↓ ∧`↓↓to↓ (↓↓partially-matched:↓
↓ ¬`(↓↓env:↓ =extended-env)
↓ ¬`(↓↓complaint-dept:↓ =augmented-cd)
↓ ¬`(↓↓remnant:↓ =rem))
↓ ∧`↓↓then↓
↓ ¬ ((cons-reduced-sequence
↓ ¬`remaining-patterns
↓ ¬`unreduced-seq) <=
↓ ε (↓↓match:↓
↓ ε`(↓↓env:↓ extended-env)
↓ ε`(↓↓else-complain-to:↓ augmented-cd)
↓ ε`(↓↓object:↓ rem)))))
↓ β`(≡> [=first-pattern !=rest-pat]
↓ ∧ (rules obj
↓ ∧`(≡> [=first-obj !=rest-obj]
↓ ¬ (↓↓match↓
↓ ¬`(first-pattern <=
↓ ε (↓↓match:↓
↓ ε`(↓↓env:↓ env)
↓ ε`(↓↓else-complain-to:↓ cd)
↓ ε`(↓↓object:↓ first-obj)) )
↓ ¬`↓↓to↓ (↓↓matched:↓
↓ π (↓↓env:↓ =extended-env)
↓ π (↓↓complaint-dept:↓ =augmented-cd))
↓ ¬`↓↓then↓
↓ ε ((cons-reduced-sequence [!rest-pat] unreduced-seq)
↓ ε@<= (↓↓match:↓
↓ π (↓↓env:↓ extended-env)
↓ π (↓↓else-complain-to:↓ augmented-cd)
↓ π (↓↓object:↓ rest-obj)) )))
↓ ∧`(↓↓else↓ (cd <= (↓↓nomatch:↓))) )))) ))]
↓ `
↓ `SEQUENCES are created by sending REDUCED-SEQUENCES $eval messages.
↓ `
↓ p[cons-sequence ≡
↓ ↓`(≡> [!=actors]
↓ ↓⊂sequence: <≡>
↓ α(cases
↓ α`(≡> (↓↓equal?↓ =object)
↓ β (rules actors
↓ β`(≡> []
↓ ∧ (rules object
↓ ∧`(≡> []
↓ ¬ (↓↓yes:↓))
↓ ∧`(↓↓else↓
↓ ¬ (↓↓no:↓))))
↓ β`(≡> [=first !=rest]
↓ ∧ (rules object
↓ ∧`(≡> [=first-obj !=rest-obj]
↓ ¬ (and
↓ ¬`(equal first first-obj)
↓ ¬`(equal rest rest-obj)) )
↓ ∧`(↓↓else↓
↓ ¬ (↓↓no:↓)) )) ))
↓ α`(≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ β (rules actors
↓ β`(≡> []
↓ ∧ (cd <= (↓↓exhausted:↓) ))


↓ `↓ ε@16↓ 	EMeta-circular Defn. of PLASMA


↓ β`(≡> [=first-actor !=rest-actors]
↓ ∧ (↓↓next:↓ first-actor
↓ ∧`(↓↓rest:↓ rest-actors))) ))
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (tell the-customer
↓ β`(↓↓left-delim:↓ (↓↓bracket:↓))
↓ β`(↓↓elements:↓ ! actors)
↓ β`(↓↓right-delim:↓ (↓↓bracket:↓)))) ))]



↓ `↓ ε@17↓ 	EMeta-circular Defn. of PLASMA


↓ `[cons-unreduced-unpack ≡
↓ ↓`(≡> [=unreduced-expression =cursor]
↓ ↓⊂unreduced-unpack <≡>
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓match-reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match↓ (unreduced-expression <=
↓ ∧`(↓↓match-reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =reduced-pattern))
↓ ∧ ↓↓then↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ extended-env)
↓ ¬ (↓↓pattern:↓
↓ ¬`(cons-reduced-unpack
↓ ε reduced-pattern
↓ ε self))) ))
↓ β (≡> (↓↓reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-unpack
↓ ∧ (unreduced-expression <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ ∧ self))
↓ β (≡> (↓↓display:↓ =the-customer)
↓ β`(tell the-customer
↓ ∧ (↓↓prefix-delim:↓ (↓↓exclamation:↓))
↓ ∧ (↓↓print:↓ unreduced-expression))) )))]
↓ `
↓ p[cons-reduced-unpack ≡
↓ ↓`(≡> [=reduced-expression =unreduced]
↓ ↓⊂reduced-unpack <≡>
↓ α (cases
↓ α`(≡> (↓↓partial-match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (↓↓match↓ (reduced-expression <=
↓ ∧ (↓↓match:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)
↓ ∧`(↓↓object:↓ obj)) )
↓ β`↓↓to↓ (↓↓matched:↓
↓ ∧`(↓↓env:↓ =extended-env)
↓ ∧`(↓↓complaint-dept:↓ =aug-cd))
↓ β`↓↓then↓ (↓↓partially-matched:↓
↓ ¬ (↓↓env:↓ extended-env)
↓ ¬ (↓↓complaint-dept:↓ aug-cd)
↓ ¬ (↓↓remnant:↓ [])) ))
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (reduced-expression <=
↓ β`(↓↓eval:↓ env)) )))]



↓ `↓ ε@18↓ 	EMeta-circular Defn. of PLASMA


↓ `Forms are created by the reader upon encountering round parantheses, ie. (...)
↓ `
↓ p[cons-form ≡
↓ ↓`(≡> [=the-expressions =cursor]
↓ ↓⊂form <≡>
↓ ↓`(self ≡
↓ α (cases
↓ α`(≡> (↓↓reduce:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (rules the-expressions
↓ β`(≡> []
↓ ∧ (cd <= ['reduce-empty-form? self]))
↓ β`(↓↓else↓
↓ ∧ (↓↓let↓
↓ ∧`{[reduce-apply-message =
↓ ¬ (↓↓reduce-apply:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)
↓ ¬`(↓↓unreduced:↓ self)
↓ ¬`(↓↓expressions:↓ the-expressions))]}
↓ ∧`(the-expressions =>
↓ ¬ (look-for-distinguished-skeleton ≡
↓ ¬`(cases
↓ ε (≡> []
↓ ε`(cons-no-arrow-transmitter
↓ π [(reduce-elements-of-sequence
↓ π`env cd the-expressions) self]))
↓ ε (≡> [=i !=rest-of-expressions]
↓ ε`(i <== 
↓ π (↓↓apply:↓ reduce-apply-message
↓ π`(↓↓else-to:↓
↓ λ (≡> (↓↓not-applicable:↓ ?)
↓ λ`(look-for-distinguished-skeleton
↓ 	 <= rest-of-expressions)))))))))))))
↓ α`(≡> (↓↓match-reduce:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (rules the-expressions
↓ β`(≡> []
↓ ∧ (cd <= ['match-reduce-empty-form? self]))
↓ β`(↓↓else↓
↓ ∧ (↓↓let↓
↓ ∧`{[match-reduce-apply-message =
↓ ¬ (↓↓match-reduce-apply:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)
↓ ¬`(↓↓unreduced:↓ self)
↓ ¬`(↓↓expressions:↓ the-expressions))]}
↓ ∧`(the-expressions =>
↓ ¬(look-for-distinguished-pattern ≡
↓ ¬ (cases
↓ ¬@(≡> []
↓ ¬`(↓↓match-reduced:↓
↓ ε (↓↓env:↓ env)
↓ ε (↓↓pattern:↓
↓ ε`(cons-arrow-transmitter <=
↓ π [(reduce-elements-of-sequence
↓ π`env cd the-expressions) self])) ))
↓ ¬@(≡> [=i !=rest-of-expressions]
↓ ¬`(i <==
↓ ε(↓↓apply:↓ match-reduce-apply-message


↓ `↓ ε@19↓ 	EMeta-circular Defn. of PLASMA


↓ ε (↓↓else-to:↓
↓ ε@(=> (↓↓not-applicable:↓ ?)
↓ ε`(look-for-distinguished-pattern
↓ πrest-of-expressions)))) )))))) )))
↓ α`(≡> (↓↓down:↓
↓ β`(↓↓cursor:↓ =new-cursor))
↓ β ((cons-delimiter-cursor
↓ β`[]
↓ β`new-cursor
↓ β`cons-form) <=
↓ ∧ (↓↓fill-in:↓ the-expressions)) )
↓ α`(≡> (↓↓cursor?↓)
↓ β cursor)
↓ α`(≡> (↓↓link-up:↓ =upward-cursor)
↓ β (cons-form
↓ β`[!(link-up-delimited
↓ ∧ the-expressions
↓ ∧ []
↓ ∧ upward-cursor
↓ ∧ cons-form)]
↓ β`upward-cursor))
↓ α`(≡> (↓↓quasi-quote:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (cons-quasi-quoted-form
↓ β`[!((cons-unreduced-sequence
↓ ∧ the-expressions
↓ ∧ cursor) <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )]
↓ β`self))
↓ α`(≡> (↓↓match-quasi-quote:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (↓↓match↓ ((cons-unreduced-sequence the-expressions cursor) <=
↓ ∧`(↓↓match-reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ β`↓↓to↓ (↓↓match-reduced:↓
↓ ∧`(↓↓env:↓ =extended-env)
↓ ∧`(↓↓pattern:↓ =reduced-pattern))
↓ β`↓↓then↓ (↓↓match-reduced:↓
↓ ∧`(↓↓env:↓ extended-env)
↓ ∧`(↓↓pattern:↓
↓ ¬ (cons-quasi-quoted-form
↓ ¬`reduced-pattern
↓ ¬`self))) ))
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β`(tell the-customer
↓ ∧ (↓↓left-delim:↓ (↓↓parenthesis:↓))
↓ ∧ (↓↓elements:↓ ! the-expressions)
↓ ∧ (↓↓right-delim:↓ (↓↓parenthesis:↓)))) )))]
↓ `
↓ p[reduce-elements-of-sequence ≡
↓ ↓`(≡> [=env =cd =the-expressions]
↓ α (rules the-expressions
↓ α`(≡> []
↓ β [])
↓ α`(≡> [=first !=rest]
↓ β [(first <=
↓ β`(↓↓reduce:↓


↓ `↓ ε@20↓ 	EMeta-circular Defn. of PLASMA


↓ ∧ (↓↓env:↓ env)
↓ ∧ (↓↓else-complain-to:↓ cd)) )
↓ β0!(reduce-elements-of-sequence env cd rest)] )))]
↓ `
↓ p[match-reduce-elements-of-sequence ≡
↓ ↓`(≡> [=env =cd =the-expressions]
↓ α (≡> []
↓ α`(↓↓match-reduced:↓
↓ β (↓↓env:↓ env)
↓ β (↓↓pattern:↓ [])) )
↓ α (≡> [first !=rest]
↓ α`(↓↓match↓ (first <= (↓↓match-reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) )
↓ β ↓↓to↓ (↓↓match-reduced:↓
↓ ∧ (↓↓env:↓ =extended-env)
↓ ∧ (↓↓pattern:↓ =match-reduced-first))
↓ β ↓↓then↓
↓ β`(↓↓match↓
↓ ∧ (match-reduce-elements-of-sequence extended-env cd rest)
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =re-extended-env)
↓ ¬ (↓↓pattern:↓ =match-reduced-rest))
↓ ∧ ↓↓then↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ re-extended-env)
↓ ¬ (↓↓pattern:↓ [match-reduced-first ! match-reduced-rest]))))))]
↓ `
↓ p[cons-quasi-quoted-form ≡
↓ ↓0(≡> [=reduced-exprs =cursor]
↓ α(cases
↓ α (≡> (↓↓eval:↓ =env)
↓ α`(cons-form
↓ β (reduced-exprs <= (↓↓eval:↓ env))
↓ β default-cursor))
↓ α (≡> (↓↓match:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓object:↓ =obj))
↓ α`(rules obj
↓ β (≡> '(!=obj-elements)
↓ β`(reduced-exprs <=
↓ ∧ (↓↓match:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)
↓ ∧`(↓↓object:↓ obj-elements)) ))
↓ β (↓↓else↓
↓ β`(cd <= (↓↓nomatch:↓) )) ))
↓ α (≡> (↓↓display:↓ =the-customer)
↓ α`(tell the-customer
↓ β (↓↓prefix-delimiter:↓ (↓↓single-quote:↓))
↓ β (↓↓left-delimiter:↓ (↓↓parenthesis:↓))
↓ β (↓↓elements:↓ ! reduced-exprs)
↓ β (↓↓right-delimiter:↓ (↓↓parenthesis:↓))) )))]



↓ `↓ ε@21↓ 	EMeta-circular Defn. of PLASMA


↓ `Transmitters are produced by reduction of forms, ie. paranthesized expressions.
↓ `
↓ `Transmitters appear in plasma in the following flavors:
↓ `
↓ ↓`no-arrow-transmitter↓ ∧`(...no-distinguished-symbols...)
↓ `
↓ ↓`arrow-transmitters↓ ∧`(target <= message)↓ π`(message => target)
↓ ∧`(target <<= message)↓ π`(message =>> target)
↓ ∧`(target <== envelope)↓ π`(envelope ==> target)
↓ `
↓ p[<= ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to: =cd)↓
↓ β ↓↓(unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=target-expression '<= =message-expression]
↓ β ↓↓then↓ (cons-arrow-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => message-expression)
↓ ∧ form)))
↓ α (≡> (↓↓match-reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=target-expression '<= =message-expression]
↓ β ↓↓then↓ (cons-arrow-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ∧0=> target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ =cd))
↓ ∧0=> message-expression)
↓ ∧ form) )) )]
↓ `
↓ p[=> ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=message-expression '=> =target-expression]
↓ β ↓↓then↓ (cons-arrow-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) => message-expression)
↓ ∧ form)))
↓ α (≡> (↓↓match-reduce-apply:↓


↓ `↓ ε@22↓ 	EMeta-circular Defn. of PLASMA


↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=message-expression '=> =target-expression]
↓ β ↓↓then↓ (cons-arrow-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) => message-expression)
↓ ∧ form) )) )]
↓ `
↓ p[cons-arrow-transmitter ≡
↓ ↓`(≡> [=reduced-target =reduced-message =form]
↓ ↓⊂arrow-transmitter <≡>
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓eval:↓ =env)
↓ β`((reduced-target <= (↓↓eval:↓ env))
↓ ∧ <= (reduced-message <= (↓↓eval:↓ env)) ))
↓ β (≡> (↓↓match:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd)
↓ ∧ (↓↓object:↓ =obj))
↓ β`(rules (equal? obj (self <= (↓↓eval:↓ env)))
↓ ∧ (≡> (↓↓yes:↓)
↓ ∧`(↓↓matched:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓complaint-dept:↓ cd)) )
↓ ∧ (≡> (↓↓no:↓)
↓ ∧`(cd <= (↓↓nomatch:↓))) ))
↓ β (≡> (↓↓unreduced?↓)
↓ β`form)
↓ β (≡> (↓↓display:↓ =the-customer)
↓ β`(form <= (↓↓display:↓ =the-customer)) )))]
↓ `
↓ p[cons-no-arrow-transmitter ≡
↓ ↓`(cases
↓ α (≡> [[] =form]
↓ `???never-happen or complain to cd???
↓ α`(never-happen 'empty-transmitter))
↓ α (≡> [[=reduced-target !=reduced-messages] =form]
↓ α`(cons-arrow-transmitter
↓ β reduced-target reduced-messages form) ))]
↓ `
↓ p[<<= ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=target-expression '<<= =message-expression]
↓ β ↓↓then↓ (cons-double-headed-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => target-expression)
↓ ∧`((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)


↓ `↓ ε@23↓ 	EMeta-circular Defn. of PLASMA


↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => message-expression)
↓ ∧ 'left
↓ ∧ form))) )]
↓ `
↓ p[=>> ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=message-expression '=>> =target-expression]
↓ β ↓↓then↓ (cons-double-headed-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ =cd)) => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) => message-expression)
↓ ∧ 'right
↓ ∧ form))) )]
↓ `
↓ p[cons-double-headed-transmitter ≡
↓ ↓`(≡> [=reduced-target =reduced-message =direction-of-arrow =form]
↓ ↓⊂double-headed-transmitter <≡>
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β ((reduced-target <= (↓↓eval:↓ env)) <<=
↓ β`(↓↓return:↓ (reduced-message <= (↓↓eval:↓ env))) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β form) ))]
↓ `
↓ p[<== ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=target-expression '<== =message-expression]
↓ β ↓↓then↓ (cons-double-shaft-transmitter
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => message-expression)
↓ ∧ 'left
↓ ∧ form))) )]
↓ `
↓ p[==> ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ [=message-expression '==> =target-expression]
↓ β ↓↓then↓ (cons-double-shaft-transmitter


↓ `↓ ε@24↓ 	EMeta-circular Defn. of PLASMA


↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => target-expression)
↓ ∧ ((↓↓reduce:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd))
↓ ¬ => message-expression)
↓ ∧ 'right
↓ ∧ form))) )]
↓ `
↓ p[cons-double-shaft-transmitter ≡
↓ ↓`(≡> [=reduced-target =reduced-envelope =direction-of-arrow =form]
↓ ↓⊂double-shaft-transmitter <≡>
↓ α(self ≡
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β ((reduced-target <= (↓↓eval:↓ env)) <==
↓ β`(reduced-envelope <= (↓↓eval:↓ env)) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β form)
↓ α`(≡> (display: =the-customer)
↓ β (form <= (↓↓display:↓ =the-customer))))))]



↓ `↓ ε@25↓ 	EMeta-circular Defn. of PLASMA


↓ `Receivers appear in plasma in the following flavors:
↓ `
↓ ↓`(≡>   message↓ β`body)
↓ ↓`(≡>>  message-without-continuation  body)
↓ ↓`(≡≡>  envelope↓ β`body)
↓ `
↓ p[≡> ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ ['≡> =pattern !=body-exprs]
↓ β ↓↓then↓
↓ β`(↓↓match↓ (pattern <= (↓↓match-reduce:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)))
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =reduced-pattern))
↓ ∧ ↓↓then↓ (cons-reduced-receiver
↓ ¬`reduced-pattern
↓ ¬`((cons-unreduced-sequentially !body-exprs)
↓ ε <= (↓↓reduce:↓
↓ π (↓↓env:↓ extended-env)
↓ π0(↓↓else-complain-to:↓ cd)))
↓ ¬`form))) ))]
↓ `
↓ p[cons-reduced-receiver ≡
↓ ↓`(≡> [=reduced-pattern =reduced-body =form]
↓ ↓⊂reduced-receiver <≡>
↓ ↓0(self ≡
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (cons-receiver env reduced-pattern reduced-body form))
↓ α`(≡> (↓↓unreduced?↓)
↓ β form)
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (tell the-customer
↓ β`(form <= (↓↓display:↓ =the-customer)))))))]
↓ `
↓ p[cons-receiver ≡
↓ ↓`(≡> [=env =reduced-pattern =reduced-body =form]
↓ ↓⊂receiver <≡>
↓ α (system-cases
↓ α`(≡> (↓↓rip-off?↓)
↓ β form)
↓ α`(≡≡> (↓↓apply:↓ =the-message
↓ β`(↓↓then-to:↓ =c)
↓ β`(↓↓else-to:↓ =cd))
↓ β (↓↓match↓
↓ β`(reduced-pattern <=
↓ ∧ (↓↓match:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓
↓ ¬ (≡> (↓↓nomatch:↓)
↓ ¬`(cd <= ['not-applicable form]) ))
↓ ∧`(↓↓object:↓ the-message) ))
↓ β`↓↓to↓ (↓↓matched:↓ (↓↓env:↓ =extended-env))
↓ β`↓↓then↓
↓ ∧ (reduced-body <= (↓↓eval:↓ extended-env))) )))]


↓ `↓ ε@26↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ p[≡>> ≡
↓ ↓`(cases
↓ α (≡> (↓↓reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =form)
↓ β (↓↓expressions:↓ =s))
↓ α`(↓↓match↓ s ↓↓to↓ ['≡>> =pattern !=body-exprs]
↓ β ↓↓then↓ (↓↓match↓ (pattern <= (↓↓match-reduce:↓
↓ ε (↓↓env:↓ env)
↓ ε (↓↓else-complain-to:↓ cd)))
↓ β ↓↓to↓ (↓↓match-reduced:↓
↓ ∧ (↓↓env:↓ =extended-env)
↓ ∧ (↓↓pattern:↓ =reduced-pat))
↓ β ↓↓then↓ (cons-double-headed-reduced-receiver
↓ ∧`reduced-pattern
↓ ∧`((cons-unreduced-sequentially !body-exprs)
↓ ¬ <= (↓↓reduce:↓
↓ ε (↓↓env:↓ extended-env)
↓ ε (↓↓else-complain-to:↓ cd))) )
↓ ∧`form)) ))]
↓ `
↓ p[cons-double-headed-reduced-receiver ≡
↓ ↓`(≡> [=reduced-pattern =reduced-body =form]
↓ ↓⊂double-headed-reduced-receiver <≡>
↓ α(self ≡
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (cons-double-headed-receiver env reduced-pattern reduced-body form) )
↓ α`(≡> (↓↓unreduced?↓)
↓ β form)
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (tell the-customer
↓ β`(form <= (↓↓display:↓ =the-customer)))) )))]
↓ `
↓ p[cons-double-headed-receiver ≡
↓ ↓`(≡> [=env =reduced-pattern =reduced-body =form]
↓ ↓⊂double-headed-receiver <≡>
↓ α (system-cases
↓ α`(≡> (↓↓rip-off?↓)
↓ β form)
↓ α`(≡≡> (↓↓return:↓ =the-message)
↓ β (reduced-body <==
↓ β`(↓↓match↓
↓ ∧`(reduced-pattern <=
↓ ¬ (↓↓match:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓
↓ ε (≡> (↓↓nomatch:↓)
↓ ε`(((↓↓complaint-dept?↓) => (my-agent)) <=
↓ π0['not-applicable form])))
↓ ¬`(↓↓object:↓ the-message) ))
↓ ∧ ↓↓to↓ (↓↓matched:↓
↓ ¬`(↓↓env:↓ =extended-env))
↓ ∧ ↓↓then↓
↓ ∧`(↓↓apply:↓
↓ ¬ (↓↓eval:↓ extended-env)
↓ ¬ (↓↓then-to:↓
↓ ¬`(≡≡> =envelope
↓ ε ((↓↓complaint-dept?↓) => (my-agent)) <=
↓ ε`[['non-existent-continuation envelope] form]) ) )))) ))]


↓ `↓ ε@27↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ `[≡≡>
↓ ↓(cases
↓ ↓ (≡> (↓↓reduce-apply:↓
↓ α(↓↓env:↓ =env)
↓ α(↓↓else-complain-to:↓ =cd)
↓ α(↓↓unreduced:↓ =form)
↓ α(↓↓expressions:↓ =s))
↓ ↓@(↓↓match↓ s ↓↓to↓ [≡≡> =patterns !=body-exprs] ↓↓then↓
↓ α(↓↓match↓
↓ α@(pattern <=
↓ α`(↓↓match-reduce:↓
↓ β (↓↓env:↓ env)
↓ β (↓↓else-complain-to:↓ cd))) ↓↓to↓
↓ α@(↓↓match-reduced:↓
↓ β(↓↓env:↓ =extended-env)
↓ β(↓↓pattern:↓ =reduced-pattern)) ↓↓then↓
↓ α@(cons-double-shaft-reduced-receiver
↓ βreduced-pattern
↓ β((cons-unreduced-sequentially body-exprs)
↓ β@<= (↓↓reduce:↓
↓ ∧⊂(↓↓env:↓ extended-env)
↓ ∧⊂(↓↓else-complain-to:↓ cd))) )
↓ α@form))))]
↓ `
↓ p[cons-double-shaft-reduced-receiver ≡
↓ ↓`(≡> [=reduced-pattern =reduced-body =form]
↓ ↓⊂double-shaft-reduced-receiver <≡>
↓ α(self ≡
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (cons-double-shaft-receiver env reduced-pattern reduced-body) )
↓ α`(≡> (↓↓unreduced?↓)
↓ β form)
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (tell the-customer
↓ β`(form <= (↓↓display:↓ =the-customer)))) )))]
↓ `
↓ p[cons-double-shaft-receiver ≡
↓ ↓`(≡> [=env =reduced-pattern =reduced-body =form]
↓ ↓⊂double-shaft-receiver <≡>
↓ α (system-cases
↓ α`(≡> (↓↓rip-off?↓)
↓ β form)
↓ α`(≡≡> =envelope
↓ β (reduced-body <=
↓ β`(↓↓match↓
↓ ∧ (reduced-pattern <=
↓ ∧`(↓↓match:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓
↓ ¬`(≡> =complaint
↓ ε (((↓↓complaint-dept?↓) => (my-agent)) <=
↓ ε`[['unrecognized-envelope complaint] form])))
↓ ¬ (↓↓object:↓ envelope)) )
↓ ∧ ↓↓to↓ (↓↓matched:↓ (↓↓env:↓ =extended-env))
↓ ∧ ↓↓then↓ (↓↓eval:↓ extended-env) ))) ))]



↓ `↓ ε@28↓ 	EMeta-circular Defn. of PLASMA


↓ `The reader produces an unreduced-quasi-quote upon encountering a single-quote, ie. '
↓ `
↓ p[cons-unreduced-quasi-quote ≡
↓ ↓`(≡> [=the-expression =cursor]
↓ ↓⊂unreduced-quasi-quote <≡>
↓ α (cases
↓ α`(≡> (↓↓reduce:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (the-expression <= (↓↓quasi-quote:↓ env) ))
↓ α`(≡> (↓↓match-reduce:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd))
↓ β (the-expression <= (↓↓match-quasi-quote:↓ env) ))
↓ α`(≡> (↓↓cursor?↓)
↓ β cursor)
↓ α`(≡> (↓↓link-up:↓ =upward-cursor)
↓ β (link-up-unary
↓ β`the-expression
↓ β`upward-cursor
↓ β`cons-unreduced-quasi-quote)) ))]
↓ `
↓ `The reader produces an unreduced-total-quote upon encountering a degree-sign, ie. ↓#
o↓#
↓ `
↓ p[cons-unreduced-total-quote ≡
↓ ↓`(≡> [=the-expression =cursor]
↓ ↓⊂unreduced-total-quote <≡>
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-total-quote
↓ ∧ the-expression
↓ ∧ self))
↓ β (≡> (↓↓match-reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match-reduced:↓
↓ ∧ (↓↓env:↓ env)
↓ ∧ (↓↓pattern:↓
↓ ∧`(cons-reduced-total-quote
↓ ¬ the-expression
↓ ¬ self)) ))
↓ β (≡> (↓↓eval:↓ =env)
↓ β`self)
↓ β (≡> (↓↓match:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd)
↓ ∧ (↓↓object:↓ =obj))
↓ β`(rules the-expression
↓ ∧ (≡> obj
↓ ∧`(↓↓matched:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓complaint-dept:↓ cd)) )
↓ ∧ (↓↓else↓
↓ ∧`(cd <= (↓↓nomatch:↓) ))))
↓ β (≡> (↓↓unreduced?↓)
↓ β`self)
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓link-up:↓ =upward-cursor)


↓ `↓ ε@29↓ 	EMeta-circular Defn. of PLASMA


↓ β`(link-up-unary
↓ ∧ the-expression
↓ ∧ upward-cursor
↓ ∧ cons-unreduced-total-quote)) )))]
↓ `
↓ p[cons-reduced-total-quote ≡
↓ ↓`(≡> [=the-expression =unreduced]
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β the-expression)
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (rules the-expression
↓ β`(≡> obj
↓ ∧ (↓↓matched:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓complaint-dept:↓ cd)) )
↓ β`(↓↓else↓
↓ ∧ (cd <= (↓↓nomatch:↓))) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced) ))]



↓ `↓ ε@30↓ 	EMeta-circular Defn. of PLASMA


↓ `[cases ≡
↓ ↓ (≡> [!=the-cases]
↓ ↓cases <≡>
↓ ↓@(≡≡> (↓↓apply:↓ =the-message (↓↓else-to:↓ =cd))
↓ α(rules the-cases
↓ α (≡> []
↓ α@(cd <= 'not-applicable) )
↓ α (≡> [=first-case !=remaining-cases]
↓ α@(first-case <==
↓ α`(↓↓apply:↓ the-message
↓ β(↓↓else-to:↓
↓ β (≡> 'not-applicable
↓ β@((cases !remaining-cases) <==
↓ ∧(↓↓apply:↓ the-message
↓ ∧ (↓↓else-to:↓ cd)) ))) )) ) )))]
↓ `
↓ `[rules ≡
↓ ↓(≡> [=the-value !=the-rules]
↓ ↓ (the-value =>
↓ ↓@(cases the-rules) ))]



↓ `↓ ε@31↓ 	EMeta-circular Defn. of PLASMA


↓ p[cons-reduced-let ≡
↓ ↓`(≡> [=reduced-equations =reduced-body =unreduced-labels]
↓ α (cases
↓ α`(≡> (↓↓eval: =env)↓
↓ β ↓↓(reduced-body <=↓
↓ β`↓↓(eval:↓
↓ ∧ (reduced-equations <= (↓↓let-eval:↓ env)) )))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-labels) ))]
↓ `
↓ p[↓↓let↓ ≡
↓ ↓`(≡> (↓↓reduce-apply:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd)
↓ α`(↓↓ unreduced:↓ =unreduced-labels)
↓ α`(↓↓expressions:↓ ['↓↓let↓ =equations !=skeletons]))
↓ α (↓↓match↓ (equations <=
↓ β`(↓↓label-reduce-collection:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd)) )
↓ α`↓↓to↓ (↓↓reduced-equations:↓
↓ β`(↓↓env:↓ extended-env)
↓ β`(↓↓reduced-expression:↓ =reduced-equations))
↓ α`↓↓then↓ (cons-reduced-let
↓ β`reduced-equations
↓ β`((cons-unreduced-sequentially
↓ ∧ skeletons
↓ ∧ (unreduced-labels <= (↓↓cursor?↓)) ) <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ extended-env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ β`unreduced-let) ))]



↓ `↓ ε@32↓ 	EMeta-circular Defn. of PLASMA


↓ p[↓↓labels↓ ≡
↓ ↓`(≡> (↓↓reduce-apply:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd)
↓ α`(↓↓unreduced:↓ =unreduced-labels)
↓ α`(↓↓expressions:↓ ['↓↓labels↓ =equations !=skeletons]))
↓ α (↓↓match↓ (equations <=
↓ β`(↓↓label-reduce-collection:↓
↓ ∧`(↓↓env:↓ =env)
↓ ∧`(↓↓else-complain-to↓: =cd)) )
↓ α`↓↓to↓ (↓↓reduced-equations:↓
↓ β`(↓↓env:↓ =extended-env)
↓ β`(↓↓reduced-expression:↓ =reduced-equations))
↓ α`↓↓then↓ (cons-reduced-labels
↓ β`reduced-equations
↓ β`((cons-unreduced-sequentially
↓ ∧ skeletons
↓ ∧ (unreduced-labels <= (↓↓cursor?↓)) )
↓ ∧`<= (↓↓reduce:↓
↓ ¬0(↓↓env:↓ extended-env)
↓ ¬0(↓↓else-complain-to:↓ cd)) )
↓ β`unreduced-labels)))]
↓ `
↓ p[cons-reduced-labels ≡
↓ ↓`(≡> [=reduced-equations =reduced-body =unreduced-labels]
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (reduced-body <=
↓ β`(↓↓eval:↓
↓ ∧ (reduced-equations <= (↓↓label-eval:↓ env) )) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-labels)) )]
↓ `
↓ p[≡ ≡↓ ↓`needs more work!!!!
↓ ↓`(cases
↓ α (≡> (↓↓match-reduce-apply:↓
↓ β (↓↓env:↓ =env)
↓ β (↓↓else-complain-to:↓ =cd)
↓ β (↓↓unreduced:↓ =unreduced)
↓ β (↓↓expressions:↓ [=identifier '≡ =expression]))
↓ α`(cons-reduced-labels
↓ β {[identifier '≡ expression]}   needs to be reduced!!!
↓ β identifier        needs to be reduced-identifier
↓ β unreduced-sequentially) )
↓ α (↓↓else↓
↓ α`(cd <= ['bad-syntax])) )]
↓ `
↓ p[cons-unreduced-sequentially ≡
↓ ↓`(≡> [=skeletons =cursor]
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓reduce:↓
↓ ∧`(↓↓env:↓ =env)
↓ ∧`(↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-sequentially <=
↓ ∧ [(rules skeletons
↓ ∧`(≡> []
↓ ¬ (cd <= 'empty-sequentially-statement))
↓ ∧`(↓↓else↓
↓ ¬ (reduce-skeletons ≡
↓ ¬`(cases
↓ ε (≡> []


↓ `↓ ε@33↓ 	EMeta-circular Defn. of PLASMA


↓ ε`[])
↓ ε (≡> [=first !=rest]
↓ ε`[(first <= (↓↓reduce:↓
↓ λ (↓↓env:↓ env)
↓ λ (↓↓else-complain-to:↓ cd)))
↓ ε`!((cons-unreduced-sequence !rest)
↓ π <= (↓↓reduce:↓
↓ λ (↓↓env:↓ env)
↓ λ (↓↓else-complain-to:↓ cd)) )]) ))))
↓ ∧ self]))
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓link-up:↓ =upward-cursor)
↓ β`(cons-unreduced-sequentially
↓ ∧ [!(link-up-delimited
↓ ∧`the-skeletons
↓ ∧`[]
↓ ∧`upward-cursor
↓ ∧`cons-unreduced-sequentially)]
↓ ∧ upward-cursor)) )))]
↓ `
↓ p[cons-reduced-sequentially ≡
↓ ↓`(≡> [=reduced-skeletons =unreduced-sequentially]
↓ α (≡> (↓↓eval:↓ =env)
↓ α`(rules reduced-skeletons
↓ β (≡> [=last]
↓ β`(last <= (↓↓eval:↓ env)) )
↓ β (≡> [=first !=rest]
↓ β`(first <= (↓↓eval:↓ =env))
↓ β`((cons-reduced-sequentially !rest)
↓ ∧ <= (↓↓eval:↓ =env)) )))
↓ α (≡> (↓↓unreduced?↓)
↓ α`unreduced-sequentially) )]



↓ `↓ ε@34↓ 	EMeta-circular Defn. of PLASMA


↓ `[cons-unreduced-in-a-cell ≡
↓ ↓`(≡> [=expression =cursor]
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-in-a-cell
↓ ∧ (expression <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ β`self))
↓ β (≡> (↓↓match-reduce↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match↓
↓ ∧ (expression <=
↓ ∧`(↓↓match-reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =reduced-pattern))
↓ ∧ ↓↓then↓ (↓↓match-reduced:↓
↓ ¬`(↓↓env:↓ extended-env)
↓ ¬`(↓↓pattern:↓
↓ ε (cons-reduced-in-a-cell
↓ ε`reduced-pattern
↓ ε`self))) ))
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓down:↓ (↓↓cursor:↓ =new-cursor))
↓ β`(cons-unary-cursor
↓ ∧ expression
↓ ∧ new-cursor
↓ ∧ cons-unreduced-in-a-cell))
↓ β (≡> (↓↓link-up:↓ =upward-cursor)
↓ β`(link-up-unary
↓ ∧ expression
↓ ∧ upward-cursor
↓ ∧ cons-unreduced-in-a-cell)) )))]
↓ `
↓ p[cons-unreduced-contents ≡
↓ ↓`(≡> [=expression =cursor]
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-contents
↓ ∧ (expression <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )
↓ ∧ self))
↓ β (≡> (↓↓match-reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match↓ (expression <=
↓ ¬`(↓↓match-reduce:↓
↓ ε (↓↓env:↓ env)


↓ `↓ ε@35↓ 	EMeta-circular Defn. of PLASMA


↓ ε (↓↓else-complain-to:↓ cd)) )
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =reduced-pattern))
↓ ∧ ↓↓then↓ (↓↓match-reduced:↓
↓ ¬`(↓↓env:↓ extended-env)
↓ ¬`(↓↓pattern:↓
↓ ε (cons-reduced-contents
↓ ε`reduced-pattern
↓ ε`self))) ))
↓ β (≡> (↓↓down:↓ (↓↓cursor:↓ =new-cursor))
↓ β`(cons-unary-cursor
↓ ∧ expression
↓ ∧ new-cursor
↓ ∧ cons-unreduced-contents)) 
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓link-up:↓ =upward-cursor)
↓ β`(link-up-unary
↓ ∧ expression
↓ ∧ upward-cursor
↓ ∧ cons-unreduced-contents)) )))]
↓ `
↓ p[cons-reduced-in-a-cell ≡
↓ ↓`(≡> [=expression =unreduced-in-a-cell]
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (cons-cell
↓ β`(expression <=
↓ ∧ (↓↓eval:↓ env) )))
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (expression <=
↓ β`(↓↓match:↓
↓ ∧ (↓↓env:↓ env)
↓ ∧ (↓↓else-complain-to:↓ cd)
↓ ∧ (↓↓object:↓ (cons-cell object))) ))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-in-a-cell) ))]
↓ `
↓ p[cons-reduced-contents ≡
↓ ↓`(≡> [=reduced-expression =unreduced-contents]
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β ((reduced-expression <= (↓↓eval:↓ env))
↓ β`<= (↓↓contents?↓) ))
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (rules ((reduced-expression <= (↓↓eval:↓ env))
↓ ∧`<= (↓↓contents?↓) )
↓ β`(≡> obj
↓ ∧ (↓↓matched:↓
↓ ∧`(↓↓env:↓ env)
↓ ∧`(↓↓else-complain-to:↓ cd)) )
↓ β`(↓↓else↓
↓ ∧ (cd <= (↓↓nomatch:↓)) )))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-contents) ))]


↓ `↓ ε@36↓ 	EMeta-circular Defn. of PLASMA


↓ `
↓ p[cons-cell ≡
↓ ↓`(≡> [@=the-cell]
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓contents?↓)
↓ β`(the-cell <= (↓↓contents?↓)))
↓ β (≡> (↓↓update:↓ =new-contents)
↓ β`(the-cell <= (↓↓update:↓ new-contents))
↓ β`self) )))]
↓ `
↓ p[<- ≡
↓ ↓`(≡> (↓↓reduce-apply:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd)
↓ α`(↓↓unreduced:↓ =form)
↓ α`(↓↓expressions:↓ [=cell-expression <- =value-expression]))
↓ α (cons-reduced-assignment
↓ α`(cell-expression <=
↓ β (↓↓reduce:↓
↓ β`(↓↓env:↓ env)
↓ β`(↓↓else-complain-to:↓ cd)) )
↓ α`(value-expression <=
↓ β (↓↓reduce:↓
↓ β`(↓↓env:↓ env)
↓ β`(↓↓else-complain-to:↓ cd)) )
↓ α`form))]
↓ `
↓ p[-> ≡
↓ ↓`(≡> (↓↓reduce-apply:↓
↓ α`(↓↓env:↓ =env)
↓ α`(↓↓else-complain-to:↓ =cd)
↓ α`(↓↓unreduced:↓ =form)
↓ α`(↓↓expressions:↓ [=value-expression -> =cell-expression]))
↓ α (cons-reduced-assignment
↓ α`(cell-expression <=
↓ β (↓↓reduce:↓
↓ β`(↓↓env:↓ env)
↓ β`(↓↓else-complain-to:↓ cd)) )
↓ α`(value-expression <=
↓ β (↓↓reduce:↓
↓ β`(↓↓env:↓ env)
↓ β`(↓↓else-complain-to:↓ cd)) )
↓ α`form))]
↓ `
↓ p[cons-reduced-assignment ≡
↓ ↓`(≡> [=reduced-cell-expression =reduced-value-expression =form]
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β ((reduced-cell-expression <=
↓ β`(↓↓eval:↓ env)) <=
↓ ∧ (↓↓update:↓
↓ ∧`(reduced-value-expression <=
↓ ¬ (↓↓eval:↓ env) ))))
↓ α`(≡> (↓↓unreduced?↓)
↓ β form) ))]



↓ `↓ ε@37↓ 	EMeta-circular Defn. of PLASMA


↓ `[plasma ≡
↓ ↓ (≡> {(↓↓input:↓ =input) (↓↓output:↓ =output) (↓↓env:↓ =env) (↓↓compaint-dept:↓ =cd)}
↓ ↓`([input output] =>
↓ α (read-reduce-eval-print ≡
↓ α`(≡> [=input-stream =output-stream]
↓ β (↓↓match↓ (input-stream <= (↓↓next?↓)) ↓↓to↓
↓ β`(↓↓next:↓ =from-reader
↓ ∧ (↓↓rest:↓ =new-input-stream)) ↓↓then↓
↓ β`(read-reduce-eval-print
↓ ∧ new-input-stream
↓ ∧ ((from-reader <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) ) <=
↓ ¬`(↓↓eval:↓ env)) <=
↓ ε (↓↓display:↓ output-stream) ))))))]



↓ `↓ ε@38↓ 	EMeta-circular Defn. of PLASMA


↓ p[cons-unary-cursor ≡
↓ ↓`(≡> [=upward-cursor =unreduced-constructor]
↓ α (↓↓let↓ {[unreduced-expression = @(↓↓future-expression:↓)]}
↓ ↓⊂unary-cursor <≡>
↓ α`(self ≡
↓ β (cases
↓ β`(≡> (↓↓go-up:↓ =cd)
↓ ∧ (upward-cursor <=
↓ ∧`(↓↓coming-up:↓
↓ ¬ (↓↓with:↓
↓ ¬`(unreduced-constructor
↓ ε $unreduced-expression
↓ ε default-cursor))
↓ ¬ (↓↓else-complain-to:↓ cd)) ))
↓ β`(≡> (↓↓go-right:↓ =cd)
↓ ∧ (cd <= 'cant))
↓ β`(≡> (↓↓go-left:↓ =cd)
↓ ∧ (cd <= 'cant))
↓ β`(≡> (↓↓go-down:↓ =cd)
↓ ∧ ($unreduced-expression <=
↓ ∧`(↓↓down:↓
↓ ¬ (↓↓cursor:↓ self)
↓ ¬ (↓↓else-complain-to:↓ cd)) ))
↓ β`(≡> (↓↓replace:↓ (↓↓with:↓ =new-expression))
↓ ∧ (cons-unary-cursor
↓ ∧`(↓↓upward-cursor:↓ upward-cursor)
↓ ∧`(↓↓unreduced-consructor:↓ unreduced-constructor)))
↓ β`(≡> (↓↓below:↓ ?)
↓ ∧ $unreduced-expression)
↓ β`(≡> (↓↓delete:↓ =cd)
↓ ∧ (cd <= 'cant))
↓ β`(≡> (↓↓coming-up:↓ (↓↓with:↓ =new-expression))
↓ ∧ ((cons-unary-cursor
↓ ∧`upward-cursor
↓ ∧`unreduced-constructor) <=
↓ ¬ (↓↓fill-in:↓ new-expression)) )
↓ β`(≡> (↓↓fill-in:↓ =x)
↓ ∧ (rules $unreduced-expression
↓ ∧`(≡> (↓↓future-expression:↓)
↓ ¬ (unreduced-expression <- x)
↓ ¬ self)
↓ ∧`(↓↓else↓
↓ `???never-happen or complain to cd???
↓ ¬ (never-happen 'expression-already-filled-in))))
↓ β`(≡> (↓↓display:↓ =the-customer)
↓ ∧ (tell the-customer
↓ ∧`(↓↓usual-print:↓ self))) ))))]
↓ `
↓ p[cons-delimiter-cursor ≡
↓ ↓`(≡> [[!=reverse-before]
↓ α`=upward-cursor
↓ α`=unreduced-constructor]
↓ α (↓↓let↓ {[after = @(↓↓future-cursor:↓)]}
↓ ↓⊂delimiter-cursor <≡>
↓ α`(self ≡
↓ β (cases
↓ β`(≡> (↓↓go-up:↓ =cd)
↓ ∧ (upward-cursor <=
↓ ∧`(↓↓coming-up:↓
↓ ¬ (↓↓with:↓
↓ ¬`(unreduced-constructor
↓ ε [!(reverse-before) !$after]


↓ `↓ ε@39↓ 	EMeta-circular Defn. of PLASMA


↓ ε default-cursor))
↓ ¬ (↓↓else-complain-to:↓ cd)) ))
↓ β`(≡> (↓↓go-right:↓ =cd)
↓ ∧ (rules $after
↓ ∧`(≡> []
↓ ¬ (cd <= (↓↓exhausted:↓) ))
↓ ∧`(≡> [=next !=rest]
↓ ¬ ((cons-delimiter-cursor
↓ ¬`[next !reverse-before]
↓ ¬`upward-cursor
↓ ¬`unreduced-constructor) <=
↓ ε (↓↓fill-in:↓ [!rest]) ) )))
↓ β`(≡> (↓↓go-left:↓ =cd)
↓ ∧ (rules reverse-before
↓ ∧`(≡> []
↓ ¬ (cd <= (↓↓exhausted:↓) ))
↓ ∧`(≡> [=previous !=reverse-initial]
↓ ¬ ((cons-delimiter-cursor
↓ ¬`reverse-initial
↓ ¬`upward-cursor
↓ ¬`unreduced-constructor) <=
↓ ε (↓↓fill-in:↓ [previous !$after])) )))
↓ β`(≡> (↓↓go-down:↓ =cd)
↓ ∧ (rules $after
↓ ∧`(≡> []
↓ ¬ (cd <= 'cant))
↓ ∧`(≡> [=next ...]
↓ ¬ (next <=
↓ ¬`(↓↓down:↓
↓ ε (↓↓cursor:↓ self)
↓ ε (↓↓else-complain-to:↓ cd)) )) ))
↓ β`(≡> (↓↓replace:↓
↓ ∧`(↓↓with:↓ =new-expression)
↓ ∧`(↓↓else-complain-to:↓ =cd))
↓ ∧ (rules $after
↓ ∧`(≡> []
↓ ¬ (cd <= 'cant))
↓ ∧`(≡> [=next !=rest]
↓ ¬ ((cons-delimiter-cursor
↓ ¬`reverse-before
↓ ¬`upward-cursor
↓ ¬`unreduced-constructor) <=
↓ ε (↓↓fill-in:↓ [new-expression !rest])) ) ))
↓ β (≡> (↓↓below:↓ =cd)
↓ β`(rules $after
↓ ∧ (≡> []
↓ ∧`(cd <= 'nothing))
↓ ∧ (≡> [=first ...]
↓ ∧`first) ))
↓ β (≡> (↓↓delete:↓ =cd)
↓ β`(rules $after
↓ ∧ (≡> []
↓ ∧`(cd <= (↓↓exhausted:↓) ))
↓ ∧ (≡>[=first !=rest]
↓ ∧`((cons-delimiter-cursor
↓ ¬ reverse-before
↓ ¬ upward-cursor
↓ ¬ unreduced-constructor) <=
↓ ¬`(↓↓fill-in:↓ rest)) ) ))
↓ β (≡> (↓↓coming-up:↓ (↓↓with:↓ =new-expression))
↓ β`(rules $after
↓ ∧ (≡> []


↓ `↓ ε@40↓ 	EMeta-circular Defn. of PLASMA


↓ `???never-happen or complain to cd???
↓ ∧`(never-happen 'appeared-out-of-nowhere))
↓ ∧ (≡> [=first !=rest]
↓ ∧`((cons-delimiter-cursor
↓ ¬ reverse-before
↓ ¬ upward-cursor
↓ ¬ unreduced-constructor) <=
↓ ¬`(↓↓fill-in:↓ [new-expression !$after])) ) ))
↓ β (≡> (↓↓fill-in:↓ =x)
↓ β`(rules $after
↓ ∧ (≡> (↓↓future-cursor:↓)
↓ ∧`(after <- x)
↓ ∧`self)
↓ ∧ (↓↓else↓
↓ `???never-happen or complain to cd???
↓ ∧`(never-happen 'expression-already-filled-in)) ))
↓ β (≡> (↓↓display:↓ =the-customer)
↓ ∧ (tell the-customer
↓ ∧`(↓↓usual-print:↓ self))) ))))]
↓ `
↓ `[link-up-delimited ≡
↓ ↓(≡> [=expressions =reverse-before =upward-cursor =unreduced-constructor]
↓ ↓ (rules expressions
↓ ↓@(≡> []
↓ ↓`[])
↓ ↓@(≡> [=first !=remainder]
↓ ↓`(↓↓let↓
↓ α{[in-between-cursor =
↓ α`(cons-delimiter-cursor
↓ βreverse-before
↓ βupward-cursor
↓ βunreduced-constructor)]}
↓ α(first <= (↓↓link-up:↓ in-between-cursor))
↓ α(↓↓let↓
↓ α {[linked-up-remainder =
↓ β@(link-up-delimited
↓ β`remainder
↓ β`[first !reverse-before]
↓ β`upward-cursor
↓ β`unreduced-constructor)]}
↓ α (in-between-cursor <=
↓ β (↓↓fill-in:↓ linked-up-remainder) )
↓ α [first !linked-up-remainder]))) ))]
↓ `
↓ p[link-up-unary ≡
↓ ↓`(≡> [=the expression =upward-cursor =unreduced-constructor]
↓ α (↓↓let↓ {[new-cursor =
↓ β (cons-unary-cursor
↓ β`upward-cursor
↓ β`unreduced-constructor)]}
↓ α`(↓↓let↓ {[new-unreduced-expression =
↓ β`(the-expression <=
↓ ∧ (↓↓link-up:↓ new-cursor))]}
↓ β (unreduced-constructor
↓ β`new-unreduced-expression
↓ β`upward-cursor) )))]



↓ `↓ ε@41↓ 	EMeta-circular Defn. of PLASMA


↓ `The reader produces unreduced-collections upon encountering curly braces, ie. {...}
↓ `
↓ p[cons-unreduced-collection ≡
↓ ↓`(≡> [=exprs =cursor]
↓ ↓⊂unreduced-collection <≡>
↓ α (self ≡
↓ α`(cases
↓ β (≡> (↓↓reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-reduced-collection
↓ ∧ (reduce-elements-of-sequence env cd exprs)
↓ ∧ self))
↓ β (≡> (↓↓match-reduce:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match↓ (match-reduce-elements-of-sequence env cd exprs)
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =match-reduced-exprs))
↓ ∧ ↓↓then↓
↓ ∧`(↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ extended-env)
↓ ¬ (↓↓pattern:↓
↓ ¬`(cons-reduced-collection
↓ ε match-reduced-exprs
↓ ε self)))))
↓ β (≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ β`(rules exprs
↓ ∧ (≡> []
↓ ∧`(cd <= (↓↓exhausted:↓) ))
↓ ∧ (≡> [=first-expr !=rest-exprs]
↓ ∧`(↓↓next:↓ first-expr
↓ ¬ (↓↓rest:↓
↓ ¬`(cons-unreduced-collection rest-exprs cursor))) )))
↓ β (≡> (↓↓down:↓ (↓↓cursor:↓ =new-cursor))
↓ β`(cons-delimiter-cursor
↓ ∧ the-expressions
↓ ∧ []
↓ ∧ new-cursor
↓ ∧ right-brace) )
↓ β (≡> (↓↓cursor?↓)
↓ β`cursor)
↓ β (≡> (↓↓display:↓ =the-customer)
↓ β`(tell the-customer
↓ ∧ (↓↓left-delim:↓ (↓↓brace:↓))
↓ ∧ (↓↓elements:↓ ! exprs)
↓ ∧ (↓↓right-delim:↓ (↓↓brace:↓))))
↓ β (≡> (↓↓quasi-quote:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(cons-unreduced-collection
↓ ∧ [!((cons-unreduced-collection exprs cursor) <=
↓ ∧`(↓↓reduce:↓
↓ ¬ (↓↓env:↓ env)
↓ ¬ (↓↓else-complain-to:↓ cd)) )]
↓ ∧ cursor))
↓ β (≡> (↓↓match-quasi-quote:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to:↓ =cd))
↓ β`(↓↓match↓ ((cons-unreduced-collection exprs cursor) <=
↓ ¬ (↓↓match-reduce:↓


↓ `↓ ε@42↓ 	EMeta-circular Defn. of PLASMA


↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)) )
↓ ∧ ↓↓to↓ (↓↓match-reduced:↓
↓ ¬ (↓↓env:↓ =extended-env)
↓ ¬ (↓↓pattern:↓ =reduced-patterns))
↓ ∧ ↓↓then↓ (↓↓match-reduced:↓
↓ ¬`(↓↓env:↓ extended-env)
↓ ¬`(↓↓pattern:↓
↓ ε (cons-unreduced-collection
↓ ε`reduced-patterns
↓ ε`self))) ))
↓ β (≡> (↓↓link-up:↓ =upward-cursor)
↓ β`(cons-unreduced-collection
↓ ∧ (link-up-delimited
↓ ∧`exprs
↓ ∧`[]
↓ ∧`upward-cursor
↓ ∧`cons-unreduced-collection)
↓ ∧ upward-cursor))
↓ β (≡> (↓↓label-reduce-collection:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to↓: =cd)) 
↓ β`([exprs env] =>
↓ ∧ (accumulate-label-identifiers ≡
↓ ∧`(≡> [=rest-eqns =extended-env]
↓ ¬ (rules rest-eqns
↓ ¬`(≡> []
↓ ε ([exprs []] =>
↓ ε`(label-reduce-equations ≡
↓ π (≡> [=rest-eqns =reduced-eqns]
↓ π`(rules rest-eqns
↓ λ (≡> []
↓ λ`(↓↓label-reduced-collection:↓
↓ 	 (↓↓env:↓ extended-env)
↓ 	 (↓↓reduced-eqns:↓
↓ 	`reduced-eqns)) )
↓ λ (≡> [=next !=remaining-eqns]
↓ λ`(label-reduce-equations
↓ 	 [!remaining-eqns]
↓ 	 [(next <=
↓ 	`(↓↓label-reduce-eqn:↓
↓ 
 (↓↓env:↓ extended-env)
↓ 
 (↓↓else-complain-to:↓ cd)))
↓ 	`!reduced-eqns]) )) ))))
↓ ¬`(≡> [[=identifier ...] !=remaining-eqns]
↓ ε (accumulate-label-identifiers
↓ ε`remaining-eqns
↓ ε`(extended-env <=
↓ π (↓↓extend:↓
↓ π`(↓↓identifier:↓ identifier)
↓ π`(↓↓binder:↓
↓ λ (cons-reduced-identifier
↓ λ`identifier))) ))) )))))
↓ β (≡> (↓↓let-reduce-collection:↓
↓ ∧ (↓↓env:↓ =env)
↓ ∧ (↓↓else-complain-to↓: =cd)) 
↓ β`([exprs env []] =>
↓ ∧ (accumulate-let-identifiers ≡
↓ ∧`(≡> [=rest-eqns =extended-env =reduced-eqns]
↓ ¬ (rules rest-eqns
↓ ¬`(≡> []
↓ ε (↓↓let-reduced-collection:↓


↓ `↓ ε@43↓ 	EMeta-circular Defn. of PLASMA


↓ ε`(↓↓env:↓ extended-env)
↓ ε`(↓↓reduced-eqns:↓ reduced-eqns)) )
↓ ¬`(≡> [=next !=remaining-eqns]
↓ ε (↓↓match↓ (next <=
↓ π`(↓↓let-reduce-eqn:↓
↓ λ (↓↓env:↓ env)
↓ λ (↓↓else-complain-to:↓ cd)) )
↓ ε`↓↓to↓ (↓↓let-reduced-eqn:↓
↓ π`(↓↓env:↓ =extended-env)
↓ π`(↓↓reduced-eqn:↓ =reduced-eqn)) 
↓ ε`↓↓then↓ (accumulate-let-identifiers
↓ π`[!remaining-eqns]
↓ π`extended-env
↓ π`[reduced-eqn !reduced-eqns]))) ))))) )))]
↓ `
↓ `REDUCED-COLLECTIONS are created by sending UNREDUCED-COLLECTIONS $reduce messages.
↓ `The UNPACK-ACTOR (ie. !) has special meaning to REDUCED-COLLECTIONS, ie. unpacking the
↓ `following expression.  But COLLECTIONS treat ! just like any other ACTOR.
↓ `
↓ p[cons-reduced-collection ≡
↓ ↓`(≡> [=reduced-exprs =unreduced-collection]
↓ ↓⊂reduced-collection <≡>
↓ α (cases
↓ α`(≡> (↓↓eval:↓ =env)
↓ β (rules reduced-exprs
↓ β`(≡> []
↓ ∧ {})
↓ β`(≡> [(↓↓is-reduced-unpack:↓ =last)]
↓ ∧ ((cons-reduced-collection last unreduced-collection)
↓ ¬`<= (↓↓eval:↓ env) ))
↓ β`(≡> [=first !=rest]
↓ ∧ {((cons-reduced-collection first) <= (↓↓eval:↓ =env))
↓ ∧`!((cons-reduced-collection !rest) <= (↓↓eval:↓ =env)) })))
↓ α`(≡> (↓↓match:↓
↓ β`(↓↓env:↓ =env)
↓ β`(↓↓else-complain-to:↓ =cd)
↓ β`(↓↓object:↓ =obj))
↓ β (rules reduced-exprs
↓ β`(≡> []
↓ ∧ (rules obj
↓ ∧`(≡> []
↓ ¬ (↓↓matched:↓
↓ ¬`(↓↓env:↓ env)
↓ ¬`(↓↓complaint-dept:↓ cd)) )
↓ ∧`(↓↓else↓
↓ ¬ (cd <= (↓↓nomatch:↓))) ))
↓ β`(≡> [(↓↓is-reduced-unpack:↓ =last)]
↓ ∧ (last <= (↓↓match:↓ (↓↓env:↓ env)
↓ ¬`(↓↓else-complain-to:↓ cd)
↓ ¬`(↓↓object:↓ obj)) ))
↓ β`(≡> [=first-pattern !=rest-pat]
↓ ∧ (rules obj
↓ ∧`(≡> [=first-obj !=rest-obj]
↓ ¬ (↓↓match↓
↓ ¬`(first-pattern <=
↓ ε (↓↓match:↓
↓ ε`(↓↓env:↓ env)
↓ ε`(↓↓else-complain-to:↓ cd)
↓ ε`(↓↓object:↓ first-obj)) )
↓ ¬`↓↓to↓ (↓↓matched:↓
↓ π (↓↓env:↓ =extended-env)
↓ π (↓↓complaint-dept:↓ =augmented-cd))


↓ `↓ ε@44↓ 	EMeta-circular Defn. of PLASMA


↓ ¬`↓↓then↓
↓ ε ((cons-reduced-collection !rest-pat) <=
↓ ε`(↓↓match:↓
↓ π (↓↓env:↓ extended-env)
↓ π (↓↓else-complain-to:↓ augmented-cd)
↓ π (↓↓object:↓ rest-obj)) )))
↓ ∧`(↓↓else↓ (cd <= (↓↓nomatch:↓))) ))))
↓ α`(≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ β (rules reduced-exprs
↓ β`(≡> []
↓ ∧ (cd <= (↓↓exhausted:↓) ))
↓ β`(≡> [=first-expr !=rest-reduced-exprs]
↓ ∧ (↓↓next:↓ first-expr
↓ ∧`(↓↓rest:↓
↓ ¬ (cons-reduced-collection
↓ ¬`rest-reduced-exprs
↓ ¬`unreduced-collection))))))
↓ α`(≡> (↓↓unreduced?↓)
↓ β unreduced-collection)
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (unreduced-collection <= (↓↓display:↓ the-customer)))
↓ α`(≡> (↓↓label-eval:↓ =env)
↓ β ([reduced-exprs env] =>
↓ β`(accumulate-label-eval-identifiers ≡
↓ ∧ (≡> [=rest-reduced-exprs =extended-env]
↓ ∧`(rules rest-reduced-exprs
↓ ¬ (≡> []
↓ ¬`(reduced-exprs =>
↓ ε (update-extended-env ≡
↓ ε`(cases
↓ π (≡> []
↓ π`extended-env)
↓ π (≡> [[=identifier '≡ =skeleton]
↓ λ !=remaining-reduced-exprs]
↓ π`(extended-env <=
↓ λ (↓↓patch:↓
↓ λ`(↓↓identifier:↓ identifier)
↓ λ`(↓↓value:↓
↓ 	 (skeleton <=
↓ 	`(↓↓eval:↓ extended-env))) ))
↓ π`(update-extended-env
↓ λ [!remaining-reduced-exprs])) ))))
↓ ∧ (≡> [[=identifier ...] !=remaining-reduced-exprs]
↓ ∧`(accumulate-label-eval-identifiers
↓ ¬ remaining-reduced-exprs
↓ ¬ (extended-env <=
↓ ¬`(↓↓extend:↓
↓ ε (↓↓identifier:↓ identifier)
↓ ε (↓↓binder:↓
↓ ε`(default-labels-evaluation-binding:
↓ π identifier))) ))) ))))) ))]
↓ `
↓ `COLLECTIONS are created by sending REDUCED-COLLECTIONS $eval messages.
↓ `
↓ p[cons-collection ≡
↓ ↓`(≡> [!=actors]
↓ ↓⊂collection: <≡>
↓ α(cases
↓ α`(≡> (↓↓next?↓ (↓↓else-complain-to:↓ =cd))
↓ β (rules actors
↓ β`(≡> []
↓ ∧ (cd <= (↓↓exhausted:↓) ))


↓ `↓ ε@45↓ 	EMeta-circular Defn. of PLASMA


↓ β`(≡> [=first-actor !=rest-actors]
↓ ∧ (↓↓next:↓ first-actor
↓ ∧`(↓↓rest:↓ {!rest-actors}))) ))
↓ α`(≡> (↓↓display:↓ =the-customer)
↓ β (tell the-customer
↓ β`(↓↓left-delim:↓ (↓↓brace:↓))
↓ β`(↓↓elements:↓ ! actors)
↓ β`(↓↓right-delim:↓ (↓↓brace:↓)))) ))]



↓ `↓ ε@46↓ 	EMeta-circular Defn. of PLASMA


↓ `[(↓↓match↓ value ↓↓to↓ pattern ↓↓then↓ body) ≡
↓ ↓(rules value
↓ ↓ (≡> pattern body) )]
↓ `
↓ `[system-cases ≡
↓ ↓(≡> [=system-receiver =normal-receiver]
↓ ↓@(≡> =message
↓ α(rules #messenger-action
↓ α@(≡> (↓↓system?↓)
↓ α`(message => system-receiver))
↓ α@(≡> (↓↓normal?↓)
↓ α`(message => normal-RECEIVER)) )))]
↓ `
↓ `YET TO BE DONE???
↓ ↓ NUMBERS
↓ ↓ RIP-OFF
↓ ↓ QUASI-QUOTE
↓ ↓ I/O STREAMS
↓ ↓`TELL
↓ ↓`USUAL-PRINT
↓ ↓ EDITOR
↓ ↓`REIFY  (for virtual parentheses)
↓ ↓ PACKAGERS
↓ ↓ SERIALIZERS